/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package juegolp2;

import Construcciones.*;
import UnidadesMilitares.*;
import java.io.*;
import MapaJuego.*;
import java.util.*;
/**
 *
 */
public class pCivilizationG 
{   private int j_nivel,j_exper,j_pobl,j_fua,j_moneda;
    private recursos j_recursos;
    private int lim_fua;
    private int lim_pobl;
    private double lim_exper;
    private double factor_exper;
    private ArrayList<Construccion> construcciones = new ArrayList();
    private ArrayList<Unidad> unidades= new ArrayList();
    private int turnoJ = 0;

    public pCivilizationG(){
        this.j_recursos = new recursos();
        this.j_nivel=1;
        this.j_exper=1;
        this.j_pobl=50;
        this.j_fua=30;
        this.j_moneda=1000;
        this.lim_pobl=300;
        this.lim_fua=30;
        this.lim_exper=10;
        this.factor_exper=1.2;
    }
    
    public void actualiza_lim_fua(){ lim_fua += 2; }
    public void actualiza_lim_pobl(){ lim_pobl += 50; }
    public void actualiza_lim_exper(){ lim_exper=factor_exper*lim_exper; }
    public void mostrar_val_actual(){
        String niv = "Nivel: ";
        String XP = "XP: ";
        String pob = "Población: ";
        String fua = "Fuaa: ";
        String madera = "Madera: ";
        String petroleo = "Petróleo: ";
        String minerales = "Mineral: ";
        String moneda = "Monedas: ";

        System.out.printf("%-30cPerú Civilization (:\n",' ');
        System.out.printf("%8c%-12s%7d%13c%-12s%7d\n", ' ',niv,j_nivel, ' ',XP,j_exper);
        System.out.printf("%8c%-12s%3d/%3d%13c%-12s%7d\n",' ',pob,j_pobl,this.lim_pobl,' ', fua, j_fua);
        System.out.printf("%8c%-12s%7d%13c%-12s%7d\n",' ',madera,j_recursos.getJ_made(),' ',petroleo,j_recursos.getJ_petro());
        System.out.printf("%8c%-12s%7d%13c%-12s%7d\n",' ',minerales,j_recursos.getJ_minerales(),' ',moneda,getJ_moneda());
        System.out.printf("\n");
    }
    public int getJ_pobl() { return j_pobl; }
    public void setJ_pobl(int j_pobl) { this.j_pobl = j_pobl; }
    public int getJ_exper() { return j_exper; }
    public void setJ_exper(int j_exper) { this.j_exper = j_exper; }
    public int getJ_moneda() { return j_moneda; }
    public void setJ_moneda(int j_moneda) { this.j_moneda = j_moneda; }
    public int getJ_fua() { return j_fua; }
    public void setJ_fua(int j_fua) { this.j_fua = j_fua; }
    public int getJ_nivel() { return j_nivel; }
    public void setJ_nivel(int j_nivel) { this.j_nivel = j_nivel; }
    public int getLim_pobl() {return this.lim_pobl;}
    public int getLim_fua() {return this.lim_fua;}
    public ArrayList<Construccion> getConstrucciones() {
        return construcciones;
    }
    public ArrayList<Unidad> getUnidades() {
        return unidades;
    }
      public void setUnidades(ArrayList<Unidad> unidades) {
        this.unidades = unidades;
    }
    public void setConstrucciones(ArrayList<Construccion> construcciones) {
        this.setConstrucciones(construcciones);
    }
     public int getTurnoJ() { return turnoJ; }
    public void setTurnoJ(int TurnoJ) { this.turnoJ = TurnoJ; }

    public void mostrar_menu_construcciones()
    {
          System.out.println("!!!!!!!!!!!!!!!!!!! MENU CONSTRUCCIONES!!!!!!!!!!!!!!!!");
          System.out.println("******************* VIVIENDAS ********************");
          System.out.println(" (1) Bungalow Pequenho ");
          System.out.println(" (2) Casa Pequenha ");
          System.out.println(" (3) Casa Moderna ");
          System.out.println(" (4) Mansion ");
          System.out.println("******************* GOBIERNO ********************");
          System.out.println(" (5) Mansion Presidencial ");
          System.out.println(" (6) Tribunal Federall ");
          System.out.println(" (7) Ayuntamiento ");
          System.out.println("******************* MILITAR ********************");
          System.out.println(" (8) Cuartel Militar ");
          System.out.println(" (9) Fuerza Aerea ");
          System.out.println(" (10) Base Naval ");
          System.out.println("******************* PRODUCCION ********************");
          System.out.println(" (11) Granero de Alimentos ");
          System.out.println(" (12) Pozo Petrolero ");
          System.out.println(" (13) Industria de Madera ");
          System.out.println(" (14) Mineria ");
          
    }
    
    public void construir(Mapa map,int x,int y)  throws IOException  {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Construccion construc=null;
        x--; y--;
        int opcion;//=-5, x=0, y=0; 
    //    int pob,cost_fua, mon;
        mostrar_menu_construcciones();
        //Se solicita qué tipo de construcción se quiere hacer
        System.out.println("¿Qué desea construir? (escribe 1)");
        opcion = Integer.parseInt(br.readLine());
        
     //   while(true)
       // {        
            if ((opcion>0)&&(opcion<=4))
            {
                    switch(opcion)
                    {
                    
                       case 1:   //esto es construir una construccion 
                       {
                        construc = new bungalowPequenho(x,y);
                        
                        int pob = ((bungalowPequenho)construc).getInc_poblacion();
                        int mon = construc.getPrecio();
                        int cost_fua=construc.getCosto_energia();
                        int mad = ((bungalowPequenho)construc).getNum_recurso();
                        if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) && 
                            (j_moneda>mon) && (j_recursos.getJ_made()>mad) && (this.j_fua>cost_fua) &&(this.lim_pobl> pob+this.j_pobl)
                                 && (this.j_nivel>=construc.getMin_nivel()))
                        {
                            map.getCelda(x,y).mod_ocupa_const(construc);
                            map.getCelda(x,y).mod_char(construc.getID());
                            this.j_pobl += pob;
                            this.j_moneda -= mon;
                            this.j_recursos.setJ_made(j_recursos.getJ_made()-mad);
                            this.setJ_fua((this.getJ_fua())-((bungalowPequenho)construc).getCosto_energia());
                            this.setJ_exper(this.getJ_exper()+((bungalowPequenho)construc).getXP());
                            getConstrucciones().add(construc);
                        }
                        else 
                        {
                            if (map.ver_celda_ocupada(x,y)==1)
                            {
                                System.out.println("La celda ya está ocupada");
                            }
                            else 
                            {
                                if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                {
                                    System.out.println("No se puede crear este edificio en este terreno");
                                }
                                else
                                    System.out.println("No cuenta con los suficientes recursos y o energia");
                            }
                        }
                       }
                        break;
                    
                        case 2:
                        {
                            construc = new casaPequenha(x,y);
                        
                            int pob= ((casaPequenha)construc).getInc_poblacion();
                            int mon = construc.getPrecio();
                            int cost_fua=construc.getCosto_energia();
                            int mad = ((casaPequenha)construc).getNum_recurso();
                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) && 
                                (j_moneda>mon) && (j_recursos.getJ_made()>mad) && (this.j_fua>cost_fua) &&(this.lim_pobl> pob+this.j_pobl)
                                 && (this.j_nivel>=construc.getMin_nivel()))
                            {
                                map.getCelda(x,y).mod_ocupa_const(construc);
                                map.getCelda(x,y).mod_char(construc.getID());
                                this.j_pobl += pob;
                                this.j_moneda -= mon;
                                this.j_recursos.setJ_made(j_recursos.getJ_made()-mad);
                                this.setJ_fua((this.getJ_fua())-((casaPequenha)construc).getCosto_energia());
                                this.setJ_exper((this.getJ_exper())+((casaPequenha)construc).getXP());
                                getConstrucciones().add(construc);
                            }
                            else 
                            {
                                if (map.ver_celda_ocupada(x,y)==1)
                                {
                                    System.out.println("La celda ya está ocupada");
                                }
                                else 
                                {
                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                    {
                                        System.out.println("No se puede crear este edificio en este terreno");
                                    }
                                    else
                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                }
                            }
                       }
                     break;
                      case 3:
                      {
                            construc = new casaModerna(x,y);
                        
                            int pob= ((casaModerna)construc).getInc_poblacion();
                            int mon = construc.getPrecio();
                            int cost_fua=construc.getCosto_energia();
                            int mad = ((casaModerna)construc).getNum_recurso();
                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) && 
                                (j_moneda>mon) && (j_recursos.getJ_made()>mad) && (this.j_fua>cost_fua) &&(this.lim_pobl> pob+this.j_pobl)
                                 && (this.j_nivel>=construc.getMin_nivel()))
                            {
                                map.getCelda(x,y).mod_ocupa_const(construc);
                                map.getCelda(x,y).mod_char(construc.getID());
                                this.j_pobl += pob;
                                this.j_moneda -= mon;
                                this.j_recursos.setJ_made(j_recursos.getJ_made()-mad);
                                this.setJ_fua((this.getJ_fua())-((casaPequenha)construc).getCosto_energia());
                                this.setJ_exper(this.getJ_exper()+((casaPequenha)construc).getXP());
                                getConstrucciones().add(construc);
                            }
                            else 
                            {
                                if (map.ver_celda_ocupada(x,y)==1)
                                {
                                    System.out.println("La celda ya está ocupada");
                                }
                                else 
                                {
                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                    {
                                        System.out.println("No se puede crear este edificio en este terreno");
                                    }
                                    else
                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                }
                            }
                       }
                       break;
                        case 4:
                      {
                            construc = new mansion(x,y);
                        
                            int pob= ((mansion)construc).getInc_poblacion();
                            int mon = construc.getPrecio();
                            int cost_fua=construc.getCosto_energia();
                            int mad = ((mansion)construc).getNum_recurso();
                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) && 
                                (j_moneda>mon) && (j_recursos.getJ_made()>mad) && (this.j_fua>cost_fua) &&(this.lim_pobl> pob+this.j_pobl)
                                 && (this.j_nivel>=construc.getMin_nivel()))
                            {
                                map.getCelda(x,y).mod_ocupa_const(construc);
                                map.getCelda(x,y).mod_char(construc.getID());
                                this.j_pobl += pob;
                                this.j_moneda -= mon;
                                this.j_recursos.setJ_made(j_recursos.getJ_made()-mad);
                                this.setJ_fua((this.getJ_fua())-((casaPequenha)construc).getCosto_energia());
                                this.setJ_exper(this.getJ_exper()+((casaPequenha)construc).getXP());
                                getConstrucciones().add(construc);
                            }
                            else 
                            {
                                if (map.ver_celda_ocupada(x,y)==1)
                                {
                                    System.out.println("La celda ya está ocupada");
                                }
                                else 
                                {
                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                    {
                                        System.out.println("No se puede crear este edificio en este terreno");
                                    }
                                    else
                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                }
                            }
                       }
                       break;
                     default: break;
                 }
                
            }    
 
                //construyeVivienda(x,y,opcion);
            else
            { 
                    if ((opcion>4)&&(opcion<=7))
                    {
                            switch(opcion)
                     {
                    
                       case 5:   //esto es construir una construccion 
                       {
                        construc = new mansionPresidencial(x,y);
                        
                        int pob = ((mansionPresidencial)construc).getBono_poblacion();
                        int mon = construc.getPrecio();
                        int cost_fua=construc.getCosto_energia();
                       
                        if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) && 
                            (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_nivel>=construc.getMin_nivel()))
                        {
                            map.getCelda(x,y).mod_ocupa_const(construc);
                            map.getCelda(x,y).mod_char(construc.getID());
                            this.lim_pobl += pob;
                            this.j_moneda -= mon;
                            
                            this.setJ_fua((this.getJ_fua())- cost_fua);
                            this.setJ_exper(this.getJ_exper()+((mansionPresidencial)construc).getXP());
                            getConstrucciones().add(construc);
                        }
                        else 
                        {
                            if (map.ver_celda_ocupada(x,y)==1)
                            {
                                System.out.println("La celda ya está ocupada");
                            }
                            else 
                            {
                                if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                {
                                    System.out.println("No se puede crear este edificio en este terreno");
                                }
                                else
                                    System.out.println("No cuenta con los suficientes recursos y o energia");
                            }
                        }
                       }
                        break;
                    
                        case 6:
                        {
                            construc = new tribunalFederal(x,y);
                        
                            int pob = ((tribunalFederal)construc).getBono_poblacion();
                            int mon = construc.getPrecio();
                            int cost_fua=construc.getCosto_energia();
                       
                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_nivel>=construc.getMin_nivel()))
                            {
                                map.getCelda(x,y).mod_ocupa_const(construc);
                                map.getCelda(x,y).mod_char(construc.getID());
                                this.lim_pobl += pob;
                                this.j_moneda -= mon;
                                this.setJ_fua((this.getJ_fua())- cost_fua);
                                this.setJ_exper(this.getJ_exper()+(construc).getXP());
                                getConstrucciones().add(construc);
                            }
                            else
                            {
                                if (map.ver_celda_ocupada(x,y)==1)
                                {
                                    System.out.println("La celda ya está ocupada");
                                }
                                else
                                {
                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                    {
                                        System.out.println("No se puede crear este edificio en este terreno");
                                    }
                                    else
                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                }
                            }
                           }
                         break;
                          case 7:
                          {
                                construc = new ayuntamiento(x,y);

                            int pob = ((ayuntamiento)construc).getBono_poblacion();
                            int mon = construc.getPrecio();
                            int cost_fua=construc.getCosto_energia();

                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_nivel>=construc.getMin_nivel()))
                            {
                                map.getCelda(x,y).mod_ocupa_const(construc);
                                map.getCelda(x,y).mod_char(construc.getID());
                                this.lim_pobl += pob;
                                this.j_moneda -= mon;
                                this.setJ_fua((this.getJ_fua())- cost_fua);
                                this.setJ_exper(this.getJ_exper()+construc.getXP());
                                getConstrucciones().add(construc);
                            }
                            else
                            {
                                if (map.ver_celda_ocupada(x,y)==1)
                                {
                                    System.out.println("La celda ya está ocupada");
                                }
                                else
                                {
                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                    {
                                        System.out.println("No se puede crear este edificio en este terreno");
                                    }
                                    else
                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                }
                               }
                               }
                                break;
                                default: //
                                break;
                            }

                          }
                            else
                        {
                            if((opcion>7)&&(opcion<=10))
                            {
                               switch(opcion)
                               {

                                case 8:   //esto es construir un edificio Militar
                                {
                                    construc = new cuartelMilitar(x,y);
                                    int mon = construc.getPrecio();
                                    int cost_fua=construc.getCosto_energia();
                                    int petroleo=((cuartelMilitar)construc).getNum_recurso();


                                    if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                        (j_moneda>mon) && (this.j_fua>cost_fua) /*(this.j_recursos.getJ_petro()>petroleo)*/

                                            &&(this.j_nivel>=construc.getMin_nivel()))
                                    {
                                        map.getCelda(x,y).mod_ocupa_const(construc);
                                        map.getCelda(x,y).mod_char(construc.getID());
                                        this.j_moneda -= mon;
                                        this.j_recursos.setJ_petro(j_recursos.getJ_petro()-petroleo);
                                        this.setJ_fua((this.getJ_fua())- cost_fua);
                                        this.setJ_exper(this.getJ_exper()+construc.getXP());
                                        getConstrucciones().add(construc);
                                    }
                                    else
                                    {
                                        if (map.ver_celda_ocupada(x,y)==1)
                                        {
                                            System.out.println("La celda ya está ocupada");
                                        }
                                        else
                                        {
                                            if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                            {
                                                System.out.println("No se puede crear este edificio en este terreno");
                                            }
                                            else
                                                System.out.println("No cuenta con los suficientes recursos y o energia");
                                        }
                                    }
                                   }
                                break;

                                case 9:   //esto es construir un edificio Militar
                                {
                                    construc = new baseNaval(x,y);
                                    int mon = construc.getPrecio();
                                    int cost_fua=construc.getCosto_energia();
                                    int petroleo=((baseNaval)construc).getNum_recurso();


                                    if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.agua)==1) &&
                                        (j_moneda>mon) && (this.j_fua>cost_fua)&&(this.j_recursos.getJ_petro()>petroleo)
                                            &&(this.j_nivel>=construc.getMin_nivel()))
                                    {
                                        map.getCelda(x,y).mod_ocupa_const(construc);
                                        map.getCelda(x,y).mod_char(construc.getID());
                                        this.j_moneda -= mon;
                                        this.j_recursos.setJ_petro(j_recursos.getJ_petro()-petroleo);
                                        this.setJ_fua((this.getJ_fua())- cost_fua);
                                        this.setJ_exper(this.getJ_exper()+construc.getXP());
                                        getConstrucciones().add(construc);
                                    }
                                    else
                                    {
                                        if (map.ver_celda_ocupada(x,y)==1)
                                        {
                                            System.out.println("La celda ya está ocupada");
                                        }
                                        else
                                        {
                                            if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                            {
                                                System.out.println("No se puede crear este edificio en este terreno");
                                            }
                                            else
                                                System.out.println("No cuenta con los suficientes recursos y o energia");
                                        }
                                    }
                                   }
                                break;

                                case 10:   //esto es construir un edificio Militar
                                {
                                    construc = new fuerzasAereas(x,y);
                                    int mon = construc.getPrecio();
                                    int cost_fua=construc.getCosto_energia();
                                    int petroleo=((fuerzasAereas)construc).getNum_recurso();

                                    if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                        (j_moneda>mon) && (this.j_fua>cost_fua)&&(this.j_recursos.getJ_petro()>petroleo)
                                            &&(this.j_nivel>=construc.getMin_nivel()))
                                    {
                                        map.getCelda(x,y).mod_ocupa_const(construc);
                                        map.getCelda(x,y).mod_char(construc.getID());
                                        this.j_moneda -= mon;
                                        this.j_recursos.setJ_petro(j_recursos.getJ_petro()-petroleo);
                                        this.setJ_fua((this.getJ_fua())- cost_fua);
                                        this.setJ_exper(this.getJ_exper()+construc.getXP());
                                        getConstrucciones().add(construc);
                                    }
                                    else
                                    {
                                        if (map.ver_celda_ocupada(x,y)==1)
                                        {
                                            System.out.println("La celda ya está ocupada");
                                        }
                                        else
                                        {
                                            if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                            {
                                                System.out.println("No se puede crear este edificio en este terreno");
                                            }
                                            else
                                                System.out.println("No cuenta con los suficientes recursos y o energia");
                                        }
                                    }
                                   }
                                    break;
                                    default: //
                                    break;
                                }

                              }

                         //construyeMilitar(x,y,opcion);
                                else
                                {
                                    if ((opcion>10)&&(opcion<=14))
                                    {
                                      switch(opcion)
                                      {

                                        case 11:
                                        {
                                            construc = new graneroAlimenticio(x,y);

                                            int mon = construc.getPrecio();
                                            System.out.println("moneda:"+ mon);
                                            int cost_fua=construc.getCosto_energia();
                                            int madera=((graneroAlimenticio)construc).getNumRecurso();

                                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                            (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_recursos.getJ_made()>madera)
                                             &&(this.j_nivel>=construc.getMin_nivel()))
                                            {
                                                map.getCelda(x,y).mod_ocupa_const(construc);
                                                map.getCelda(x,y).mod_char(construc.getID());
                                                this.j_recursos.setJ_made(j_recursos.getJ_made()-madera);
                                                this.j_moneda -= mon;
                                                this.setJ_fua((this.getJ_fua())- cost_fua);
                                                this.setJ_exper(this.getJ_exper()+construc.getXP());
                                                getConstrucciones().add(construc);
                                            }
                                            else
                                            {
                                                if (map.ver_celda_ocupada(x,y)==1)
                                                {
                                                    System.out.println("La celda ya está ocupada");
                                                }
                                                else
                                                {
                                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                                    {
                                                        System.out.println("No se puede crear este edificio en este terreno");
                                                    }
                                                    else
                                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                                }
                                            }
                                           }
                                        break;

                                        
                                        case 12:
                                        {
                                            construc = new pozoPetrolero(x,y);

                                            //int pob = ((mansionPresidencial)construc).getBono_poblacion();
                                            int mon = construc.getPrecio();
                                            int cost_fua=construc.getCosto_energia();
                                            int madera=((pozoPetrolero)construc).getNumRecurso();

                                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                               (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_recursos.getJ_made()>madera)&&
                                                (this.j_nivel>=construc.getMin_nivel()))
                                            {
                                                map.getCelda(x,y).mod_ocupa_const(construc);
                                                map.getCelda(x,y).mod_char(construc.getID());
                                                this.j_recursos.setJ_made(j_recursos.getJ_made()-madera);
                                                this.j_moneda -= mon;
                                                this.setJ_fua((this.getJ_fua())- cost_fua);
                                                this.setJ_exper(this.getJ_exper()+construc.getXP());
                                                getConstrucciones().add(construc);
                                            }
                                            else
                                            {
                                                if (map.ver_celda_ocupada(x,y)==1)
                                                {
                                                    System.out.println("La celda ya está ocupada");
                                                }
                                                else
                                                {
                                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                                    {
                                                        System.out.println("No se puede crear este edificio en este terreno");
                                                    }
                                                    else
                                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                                }
                                            }
                                           }
                                        break;
                                        case 13:
                                        {
                                            construc = new aserradero(x,y);
                                            int mon = construc.getPrecio();
                                            int cost_fua=construc.getCosto_energia();
                                            int madera=((aserradero)construc).getNumRecurso();

                                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                               (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_recursos.getJ_made()>madera) &&
                                               (this.j_nivel>=construc.getMin_nivel()))
                                            {
                                                map.getCelda(x,y).mod_ocupa_const(construc);
                                                map.getCelda(x,y).mod_char(construc.getID());
                                                this.j_recursos.setJ_made(j_recursos.getJ_made()-madera);
                                                this.j_moneda -= mon;
                                                this.setJ_fua((this.getJ_fua())- cost_fua);
                                                this.setJ_exper(this.getJ_exper()+construc.getXP());
                                                getConstrucciones().add(construc);
                                            }
                                            else
                                            {
                                                if (map.ver_celda_ocupada(x,y)==1)
                                                {
                                                    System.out.println("La celda ya está ocupada");
                                                }
                                                else
                                                {
                                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                                    {
                                                        System.out.println("No se puede crear este edificio en este terreno");
                                                    }
                                                    else
                                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                                }
                                            }
                                           }
                                        break;
                                        case 14:
                                        {
                                            construc = new minaMetales(x,y);

                                            //int pob = ((mansionPresidencial)construc).getBono_poblacion();
                                            int mon = construc.getPrecio();
                                            int cost_fua=construc.getCosto_energia();
                                            int madera=((minaMetales)construc).getNumRecurso();

                                            if((map.ver_celda_ocupada(x,y)==0) && (map.buen_terreno(x,y,tipoTerreno.arena)==1) &&
                                            (j_moneda>mon) && (this.j_fua>cost_fua) && (this.j_recursos.getJ_made()>madera))
                                            {
                                                map.getCelda(x,y).mod_ocupa_const(construc);
                                                map.getCelda(x,y).mod_char(construc.getID());
                                                this.j_recursos.setJ_made(j_recursos.getJ_made()-madera);
                                                this.j_moneda -= mon;
                                                this.setJ_fua((this.getJ_fua())- cost_fua);
                                                this.setJ_exper(this.getJ_exper()+construc.getXP());
                                                getConstrucciones().add(construc);
                                            }
                                            else
                                            {
                                                if (map.ver_celda_ocupada(x,y)==1)
                                                {
                                                    System.out.println("La celda ya está ocupada");
                                                }
                                                else
                                                {
                                                    if (map.buen_terreno(x,y,tipoTerreno.arena)==0)
                                                    {
                                                        System.out.println("No se puede crear este edificio en este terreno");
                                                    }
                                                    else
                                                        System.out.println("No cuenta con los suficientes recursos y o energia");
                                                }
                                            }
                                           }
                                            break;
                                          default:
                                              break;
                                }

                              }

                                else
                                    System.out.println("Opcion Inválida, Ingrese item correcto");
                            }
                        }


    
        }
    }
    public void imprimirMenuObjetos(){
          System.out.println("!!!!!!!!!!!!!!!!!!!!! MENU OBJETOS!!!!!!!!!!!!!!!!!!");
          System.out.println("******************* CUARTEL ********************");
          System.out.println(" (1) Soldado ");
          System.out.println(" (2) Tanque simple ");
          System.out.println("****************** FUERZA AEREA*****************");
          System.out.println(" (3) Avión simple ");
          System.out.println("******************* BASE NAVAL *****************");
          System.out.println(" (4) Barco de Guerra ");
          System.out.println("************** GRANERO ALIMENTICIO *************");
          System.out.println(" (5) Cultivar fresas ");
          System.out.println("****************** ASERRADERO ******************");
          System.out.println(" (6) Talar leños ");
          System.out.println("****************** MINA METALES ****************");
          System.out.println(" (7) Excavar mineral ");
          System.out.println("**************** POZO PETROLERO ****************");
          System.out.println(" (8) Contratar pozos ");
    }
    public void crear(Mapa map,int x,int y, ArrayList<Unidad> unidades){
        /*Los parámetros del comando crear serán cualquier coordenada X, Y que
         contenga una construcción, y el objeto o personaje a crear. La ejecución
         del comando deberá validar que exista una construcción en la celda X, Y
         indicada y, de ser el caso, deberá indicar la conformidad de la recolección. */
         Scanner lector = new Scanner(System.in);
         x--; y--;
         int opcion;
         boolean sms=true;

         //Se solicita qué tipo de construcción se quiere hacer
         if (map.getCelda(x, y).sacaConstruccion()!=null)
         {
            tipoConst constr=map.getCelda(x, y).sacaConstruccion().getTipoC();
            Construccion construccion = map.getCelda(x, y).sacaConstruccion();
            Unidad s;


            imprimirMenuObjetos();
            opcion = lector.nextInt();
            switch (opcion)
            {
                case 1: {
                            if (constr!=tipoConst.cuartelMilitar)
                            {
                                System.out.println(" (!) No puede crear un soldado, esta edificación no es un cuartel ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) El cuartel no está disponible para una nueva creación ");
                                    sms=false;
                                }
                                else
                                {
                                    //creo una unidad
                                    s=((cuartelMilitar)construccion).producirSoldado(x,y);
                                    if((j_moneda>s.getCosto_unidad()))
                                    {
                                        j_moneda -= s.getCosto_unidad();
                                        //cambio el estado de la unidad
                                        s.setEstado(2); //en creación
                                        //cambio el estado del edificio
                                        construccion.setestado(1);//trabajando
                                        //introduzco la unidad al arreglo de unidades
                                        unidades.add(s);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear una unidad ");
                                        s.setEstado(4); //eliminado
                                    }
                                }
                            }
                            break;
                        }
                case 2: {
                            if (constr!=tipoConst.cuartelMilitar)
                            {
                                System.out.println(" (!) No puede crear un tanque simple, esta edificación no es un cuartel ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) El cuartel no está disponible para una nueva creación ");
                                    sms=false;
                                }
                                else
                                {
                                    s=((cuartelMilitar)construccion).producirTanqueSimple(x, y);
                                    if((j_moneda>s.getCosto_unidad()))
                                    {
                                        j_moneda -= s.getCosto_unidad();
                                        s.setEstado(2);
                                        construccion.setestado(1);
                                        unidades.add(s);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear una unidad ");
                                        s.setEstado(4);
                                    }
                                }
                            }
                            break;
                        }
                case 3: {
                            if (constr!=tipoConst.fuerzasAereas)
                            {
                                System.out.println(" (!) No puede crear un avión simple, esta edificación no es una base aérea ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) El base aérea no está disponible para una nueva creación ");
                                    sms=false;
                                }
                                else
                                {
                                    s=((fuerzasAereas)construccion).producirAvionSimple(x, y);
                                    if((j_moneda>s.getCosto_unidad()))
                                    {
                                        j_moneda -= s.getCosto_unidad();
                                        s.setEstado(2);
                                        construccion.setestado(1);
                                        unidades.add(s);
                                     }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear una unidad ");
                                        s.setEstado(4);
                                    }
                                }
                            }
                            break;
                        }
                case 4: {
                            if (constr!=tipoConst.baseNaval)
                            {
                                System.out.println(" (!) No puede crear un barco de guerra, esta edificación no es una base naval ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) La base naval no está disponible para una nueva creación ");
                                    sms=false;
                                }
                                else
                                {
                                    s=((baseNaval)construccion).producirBarcoGuerra(x, y);
                                    if((j_moneda>s.getCosto_unidad()))
                                    {
                                        j_moneda -= s.getCosto_unidad();
                                        s.setEstado(2);
                                        construccion.setestado(1);
                                        unidades.add(s);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear una unidad ");
                                        s.setEstado(4);
                                    }
                                }
                            }
                            break;
                        }
                case 5: {
                            if (constr!=tipoConst.graneroAlimenticio)
                            {
                                System.out.println(" (!) No puede cultivar fresas, esta edificación no es un granero ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) La granja no está disponible para un nuevo cultivo ");
                                    sms=false;
                                }
                                else
                                {
                                    if((j_moneda>construccion.getPrecio()))
                                    {
                                        j_moneda -=30;
                                        construccion.setestado(1);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear continuar ");
                                    }
                                }

                            break;
                        }
                }
                case 6: {
                            if (constr!=tipoConst.aserradero)
                            {
                                System.out.println(" (!) No puede talar, esta edificación no es un aserradero ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) El aserradero no está disponible para talar ");
                                    sms=false;
                                }
                                else
                                {
                                    if((j_moneda>construccion.getPrecio()))
                                    {
                                        j_moneda -=30;
                                        construccion.setestado(1);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear continuar ");
                                    }
                                }
                            }
                            break;
                        }
                case 7: {
                            if (constr!=tipoConst.minaMetales)
                            {
                                System.out.println(" (!) No puede extraer metales, esta edificación no es una mina ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) La mina no está disponible para extraer ");
                                    sms=false;
                                }
                                else
                                {
                                    if((j_moneda>construccion.getPrecio()))
                                    {
                                        j_moneda -=30;
                                        construccion.setestado(1);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear continuar ");
                                    }
                                }
                            }
                            break;
                        }
                case 8: {
                            if (constr!=tipoConst.pozoPetrolero)
                            {
                                System.out.println(" (!) No puede explotar el pozo, esta edificación no es un pozo ");
                                sms=false;
                            }
                            else {
                                if (construccion.getestado()!=3){ // la construcción está ocupada
                                    System.out.println(" (!) El pozo no está disponible para explotar ");
                                    sms=false;
                                }
                                else
                                {
                                    if((j_moneda>construccion.getPrecio()))
                                    {
                                        j_moneda -=30;
                                        construccion.setestado(1);
                                    }
                                    else {
                                        System.out.println(" (!) No tiene recursos suficientes para crear continuar ");
                                    }
                                }
                            }
                            break;
                        }
                default: {
                            break;
                         }
            }
         }
         else
         {
            System.out.println(" (!) No se puede crear ninguna unidad ");
            sms=false;
         }
         if (sms=true) System.out.println(" La unidad se ha empezado a crear ;) ");
    }
    public void recolectar(Mapa map,int x,int y,ArrayList<Unidad> unidades){
        int entero1, entero2;
        x--; y--; //no quites esta linea
       Unidad auxunidad=null;
       //Analizo Construcion del parametro x e y
        if (map.getCelda(x, y).sacaConstruccion()!=null){
               Construccion Construct=map.getCelda(x, y).sacaConstruccion();
              switch (Construct.getestado()){  //en q estado me encuentro

                  case 1: System.out.printf("esta trabajando-no molestar ");//estoy trabajando


                 


                  case 2:{ //termine de trabajar ya lo cree(se viazualiza en el mapa)
                      
                      char c=Construct.getID(); int var;
                      //El recolectar se separa x viviendas,Industrias y Unidades(cada uno genera algo diferente)
                       //Aqui es Viviendas todas aumentan un numero diferente de recompensa
                      if (c=='M'||c=='C'||c=='b'||c=='c'||c=='p'||c=='f'||c=='A')
                      {
                           //todas las viviendas generan moneda,ademas tenemos q volver a setear al max los turnos para poder volver a construir
                              Construct.setNum_turno(Construct.getMaximoturno());
                               int pob = ((Vivienda)Construct).getRecompensa();
                               this.j_moneda+=pob;
                               Construct.setestado(3);  //cambio el estado de construccion a libre
                               map.getCelda(x, y).mod_char(Construct.getID());
                      }
                      else //Es industria en la q cada Industria genera diferentes cosas para diferentes recursos
                        if (c=='Z'||c=='G'||c=='+'||c=='o'){
                               int pob = ((Industria)map.getCelda(x, y).sacaConstruccion()).getNumRecGenerado();
                               Construct.setNum_turno(Construct.getMaximoturno());
                               Construct.setestado(3);
                                if (c=='Z') this.j_moneda+=pob+10;
                                if (c=='G')  this.j_recursos.setJ_petro(pob+this.j_recursos.getJ_petro());
                                if (c=='+') this.j_recursos.setJ_made(pob+this.j_recursos.getJ_made());
                               //if (c=='o') this.j_recursos.setJ_minerales(pob+this.j_recursos.getJ_minerales());
                               map.getCelda(x, y).mod_char(Construct.getID());
                           }
                      else // Es una contruccion militar
                      {
                        
                        for (int i=0;i<=unidades.size();i++){

                            auxunidad=unidades.get(i);
                            if (auxunidad.getX()==x && auxunidad.getY()== y)break;
                        }
                                //trabajo con el arraylist de mis unidades
                                 //seteo el estado de unidades a listo(2)
                            auxunidad.setEstado(2);
                            char id=auxunidad.getID();
                            System.out.println("Desea colocar su unidad en el mapa? Si=1 No=0");
                            Scanner lector = new Scanner(System.in);
                            int entero = lector.nextInt();
                            if(entero==1){

                                while (true){
                                    System.out.println("En que posicion x,y desea ubicarlo?");
                                    entero1 = lector.nextInt(); entero1--;
                                    entero2 = lector.nextInt(); entero2--;
                                    if (map.getCelda(entero1, entero2).sacaConstruccion()==null &&
                                        map.getCelda(entero1, entero2).sacaUnidad()==null &&
                                        map.getCelda(entero1, entero2).tipo()== auxunidad.getTipoTerreno()){
                                             Construct.setestado(3); //cambio el estado de la construccion a libre (3)
                                             auxunidad.setEstado(3); //cambio el estado de "unidad en el mapa" (3)
                                             map.getCelda(x, y).mod_char(Construct.getID());//cambio el carater ! x el suyo propio
                                             (Construct).setNum_turno((Construct).getMaximoturno());//seteo turno en la cantidad max definida
                                              break;
                                    }
                                    else System.out.println("Posicion no valida");
                                }
                                celda auxcelda=map.getCelda(entero1,entero2);
                                auxcelda.mod_char(id);
                            }



                       }
                    }//Fin case 2
                   case 3: System.out.printf("No hay nada seleccionado ");//esta libre para usar el comando crear
            }//Fin del switch
           
        }
       else System.out.printf("no hay construcion en las codenadas %d,%d",x,y);



   }






    public void actualizaturnos(Mapa mapa,ArrayList<Construccion> construcciones){

        int i=0;
        Construccion auxcons;
        for (i=0;i<construcciones.size();i++){
            auxcons=construcciones.get(i);
            int N=auxcons.getNum_turno();
            if (N>0&& auxcons.getestado()==1) auxcons.setNum_turno(N-1);
            if (auxcons.getNum_turno()==0){//si turno es igual a 0 signifca q ya esta listo
               auxcons.setestado(2); //seteo el estado de construcciones a 2 q significa q tmb esta listo
                celda auxcelda;
                auxcelda=(mapa.getCelda(auxcons.getPos_x(),auxcons.getPos_y()));
                auxcelda.mod_char('!');//cambio el carater para q vizualente se note q en la construccion ya ay algo listo y
                //para psoteriormente usar el comando recolectar

        }
            System.out.print("Paso un turno");
    }
        
   
    }
    public static void Interfaz(){

		System.out.print("Ingrese el comando (1-<construir,2<- recolectar,3<-crear,4<-turno, 5<-salir):\n ? ");
	}


    public void jugar() throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //Crea el mapa
        Mapa map = new Mapa(20,20);//lo inicializamos manualmente tmb podria ser en parametros
        map.initab(20,20);
        boolean sal=false;//condicional para confirmacion de salida
        while (true)
        {
            mostrar_val_actual(); //Muestra los valores de los recursos, energía, población, etc. en todo momento del juego
            map.imprimetab(); //Muestra el mapa en pantalla
            Interfaz();
            
            Scanner lector = new Scanner(System.in);
            int entero = lector.nextInt();
            //Scanner sc=
            switch(entero)
            {
              
                case 1: {//construir
                    System.out.print("Elija parametros X e Y \n");
                    int x = lector.nextInt();
                    int y = lector.nextInt();
                    construir(map,x,y); break;
                             
                
                       }
                case 2:{//recolectar
                    System.out.print("Elija parametros X e Y");
                    int x = lector.nextInt();
                    int y = lector.nextInt();
                    recolectar(map,x,y,unidades); break;
                                       
                }
                                        
                case 3:{ //crea
                    System.out.print("Elija parametros X e Y");
                    int x = lector.nextInt();
                    int y = lector.nextInt();
                    crear(map,x,y,unidades);
                    break;
                    
                    
                }
                //solo actualiza los turnos de las construcciones
                case 4:actualizaturnos(map,construcciones);break; 
                 
                case 5:  { //Confirmacion si el usuario desea salir
                    System.out.print("en verdad desea salir? 1.Si 0.No");
                    int ent = lector.nextInt();
                     if (ent==1) sal=true;
                     else sal=false;
                };
                
                default: break;
            }
            
            if (sal==true)
               
                break;
        }
        
    }


  
}


